/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include "基本类型.h"
#include <string>


inline int64 f_取位置数值(const int64 num, const int32 pos) {
	int64 temp = 1;
	for (int i = 0; i < pos - 1; i++)
		temp *= 10;

	return (num / temp) % 10;
}
inline uint64 f_取位置数值(const uint64 num, const int32 pos) {
	uint64 temp = 1;
	for (int i = 0; i < pos - 1; i++)
		temp *= 10;

	return (num / temp) % 10;
}


Inline std::u16string f_整数值转宽字符串(const uint32 值) {
	std::u16string str;
	bool 是否记录 = false;

	if (!值) {
		str += 48;
	}
	else {
		for (int8 i = 10; i > 0; --i) {
			uint32 新值 = uint32(f_取位置数值(uint64(值), i));
			if (新值 && !是否记录) 是否记录 = true;

			if (是否记录) {
				str += uint32(fabs(新值) + 48);
			}
		}
	}
	
	return str;
}

Inline std::u16string f_整数值转宽字符串64(const uint64 值) {
	std::u16string str;
	bool 是否记录 = false;

	if (!值) {
		str += 48;
	}
	else {
		for (int8 i = 19; i > 0; --i) {
			uint32 新值 = uint32(f_取位置数值(值, i));
			if (新值 && !是否记录) 是否记录 = true;

			if (是否记录) {
				str += int32(fabs(新值) + 48);
				//str.insert(str.begin(), 新值 + 48);
			}
		}
	}
	return str;
}


inline std::string f_整数值转字符串(const uint32 值) {
	std::string str;
	bool 是否记录 = false;

	if (!值) {
		str += 48;
	}
	else {
		for (int8 i = 10; i > 0; --i) {
			uint32 新值 = uint32(f_取位置数值(uint64(值), i));
			if (新值 && !是否记录) 是否记录 = true;

			if (是否记录) {
				str += int8(fabs(新值) + 48);
				//str.insert(str.begin(), 新值 + 48);
			}
		}
	}

	return str;
}



inline std::string f_整数值转字符串(int32 值) {
	std::string str;
	bool 是否记录 = false;

	if (值 < 0) {
		str += "-";
		值 = -值;
	}


	if (!值) {
		str += 48;
	}
	else {
		for (int8 i = 10; i > 0; --i) {
			int32 新值 = f_取位置数值(int64(值), i);
			if (新值 && !是否记录) 是否记录 = true;

			if (是否记录) {
				str += int8(fabs(新值) + 48);
				//str.insert(str.begin(), 新值 + 48);
			}
		}
	}

	return str;
}

inline std::string f_整数值转字符串(uint64 值) {
	std::string str;
	bool 是否记录 = false;

	if (!值) {
		str += 48;
	}
	else {
		for (int8 i = 24; i > 0; --i) {
			uint32 新值 = uint32(f_取位置数值(值, i));
			if (新值 && !是否记录) 是否记录 = true;

			if (是否记录) {
				str += int8(fabs(新值) + 48);
				//str.insert(str.begin(), 新值 + 48);
			}
		}
	}

	return str;
}




inline std::u16string f_整数值转宽字符串(const int32 值, uint8 位数 = 10) {
	std::u16string str;
	bool 是否记录 = false;

	if (!值) {
		str += 48;
	}
	else {
		if (值 < 0) {
			str += u"-";
		}
		else if (值 == 0) {
			str += u"0";
			return str;
		}

		for (int8 i = 位数; i > 0; --i) {
			int32 新值 = f_取位置数值(int64(值), i);
			if (新值 && !是否记录) 是否记录 = true;

			if (是否记录) {
				str += uint16(fabs(新值) + 48);
				//str.insert(str.begin(), 新值 + 48);
			}
		}
	}

	return str;
}

inline std::u16string f_浮点数值转宽字符串(float32 值, const uint8 小数显示数量=6) {
	std::wstring str = std::to_wstring(值);

	while (str.size()) {
		if (str.back() == L'0') {
			str.pop_back();
		}
		else if (str.back() == L'.') {
			str.push_back(L'0');
			break;
		}
		else {
			break;
		}
	}
	return std::u16string(str.begin(), str.end());

}





inline std::string f_浮点数值转字符串(float32 值, const uint16 小数显示数量 = 6) {
	std::string str;
	bool 是否记录 = false;

	int8 text[40];
	
	if (值 < 0.000000001 && 值 >= 0) {
		值 = 0.000000001;
	}
	if (值 > -0.000000001 && 值 < 0) {
		值 = -0.000000001;
	}

	sprintf(text, "%.8f", 值);

	for (int8 i = 0; i < 32; ++i) {
		if (text[i] == '\0') break;
		str += int16(text[i]);
	}
	if (str.size()) {
		for (uint8 i = 0; i < 10; ++i) {
			if (str.back() == '0') {
				str.pop_back();
			}
			else {
				if (str.back() == '.')
					str.push_back('0');
				break;
			}
		}
	}
	
	return str;

}








int32 f_字符串转I32(const std::u16string& text);
int32 f_字符串转I32(const std::string& text);

float32 f_字符串转F32(const std::u16string& text);


Inline std::string f_strVal_整数转16进制字符串(uint8* src, uint8 位数 = 4) {
	std::string 结果 = "";

	for (uint8 i = 0; i < 位数; ++i) {
		结果 += 48 + src[i*2] % 16;
		结果 += 48 + src[i*2+1] / 16;
	}
	
	return 结果;
}




inline uint32 f_value_整数值转字符索引(const int32 值, wchar_t t[11], uint8 位数 = 10) {
	std::wstring str;
	bool 是否记录 = false;

	uint32 num = 0;
	if (值 == 0) {
		t[0] = L'0';
		return 1;
	}
	else if (值 < 0) {
		t[0] = L'-';
		++num;
	}

	for (int8 i = 位数; i > 0; --i) {
		int32 新值 = f_取位置数值(int64(值), i);
		if (新值 && !是否记录) 是否记录 = true;

		if (是否记录) {
			t[num] = uint16(fabs(新值) + 48);
			++num;
		}
	}
	return num;
}

inline uint32 f_value_整数值转字符索引(const uint32 值, wchar_t t[11], uint8 位数 = 10) {
	std::wstring str;
	bool 是否记录 = false;

	uint32 num = 0;
	if (值 == 0) {
		t[0] = L'0';
		return 1;
	}

	for (int8 i = 位数; i > 0; --i) {
		int32 新值 = f_取位置数值(uint64(值), i);
		if (新值 && !是否记录) 是否记录 = true;

		if (是否记录) {
			t[num] = uint16(fabs(新值) + 48);
			++num;
		}
	}
	return num;
}


inline std::string f_布尔转字符串(bool 值) {
	if (值) {
		return "true";
	}
	else {
		return "false";
	}
}



Inline std::string f_strVal_转中文数字(std::string v, bool 单位) {
	std::string 结果 = "";

	bool 忽略0 = false;
	std::string 位;
	int32 num = v.size();

	for (uint8 i = 0; i < num; ++i) {
		switch (v[i]) {
			case 48: {
				if (忽略0 == false || 单位 == false) {
					结果 += "零";
				}
				break;
			}
			case 49: {
				结果 += "一";
				break;
			}
			case 50: {
				结果 += "二";
				break;
			}
			case 51: {
				结果 += "三";
				break;
			}
			case 52: {
				结果 += "四";
				break;
			}
			case 53: {
				结果 += "五";
				break;
			}
			case 54: {
				结果 += "六";
				break;
			}
			case 55: {
				结果 += "七";
				break;
			}
			case 56: {
				结果 += "八";
				break;
			}
			case 57: {
				结果 += "九";
				break;
			}
			default:
				break;
		}

		if (单位) {
			switch (num - i) {
				case 4: {
					结果 += "千";
					break;
				}
				case 3: {
					结果 += "百";
					break;
				}
				case 2: {
					if (num == 2 && v[i] < 50) {
						结果 = "十";
						//goto To_结束;

						忽略0 = true;
					}
					else {
						结果 += "十";
					}
					
					
					break;
				}
			}
		}
	}

	return 结果;
}




//if (!值) {
//	str += 48;
//}
//else {
//	int32 整数部分 = 0;
//	int32 小数部分 = int32(modf(值, (float32*)& 整数部分) * 1000000000);
//	整数部分 = int32(值);
//	if (值 < 0) str += "-";
//
//	for (int8 i = 10; i > 0; --i) {
//		int32 新值 = f_取位置数值(int64(整数部分), i);
//		if (新值 && !是否记录) 是否记录 = true;
//
//		if (是否记录) {
//			str += int8(fabs(新值) + 48);
//			//str.insert(str.begin(), 新值 + 48);
//		}
//	}
//	if (!str.size() || str[0] == '-') str += "0";
//	str += ".";
//
//	if (小数部分 == 0) {
//		str += "0";
//	}
//	else {
//		是否记录 = false;
//		for (int8 i = 10; i > 0; --i) {
//			int32 新值 = f_取位置数值(int64(小数部分), i);
//			if (新值 && !是否记录) 是否记录 = true;
//			if (是否记录) {
//				str += uint8(fabs(新值) + 48);
//				//str.insert(str.begin(), 新值 + 48);
//			}
//		}
//	}
//
//
//
//}



//inline uint32 f_value_浮点数转字符索引(const float32 值, wchar_t t[10], uint8 小数位数 = 6) {
//	std::wstring str;
//	bool 是否记录 = false;
//
//	int8 text[32];
//	sprintf(text, "%.8f", 值);
//
//	for (int8 i = 0; i < 32; ++i) {
//		if (text[i] == '\0') break;
//		str += int16(text[i]);
//	}
//	for (uint8 i = 0; i < 10; ++i) {
//		if (str.back() == L'0') {
//			str.pop_back();
//		}
//		else {
//			if (str.back() == L'.')
//				str.push_back(L'0');
//			break;
//		}
//	}
//	return str;
//}



	//bool 是否记录 = false;
	//
	//int8 text[32];
	//if (值 < 0.000000001 && 值 >= 0) {
	//	值 = 0.000000001;
	//}
	//if (值 > -0.000000001 && 值 < 0) {
	//	值 = -0.000000001;
	//}
	//
	//if (值 > 3141592653) {
	//	值 = 3141592653;
	//}
	//if (值 <= -3.41950397e+37) {
	//	值 = -3.4e+37;
	//}
	//std::to_wstring(值);
	//
	//int8 ini[5] = "%.8f";
	//ini[2] = 小数显示数量 + 48;
	//sprintf(text, ini, 值);
	//
	//for (int8 i = 0; i < 32; ++i) {
	//	if (text[i] == '\0') break;
	//	str += int16(text[i]);
	//}
	//for (uint8 i = 0; i < 10; ++i) {
	//	if (str.back() == L'0') {
	//		str.pop_back();
	//	}
	//	else {
	//		if(str.back() == L'.')
	//			str.push_back(L'0');
	//		break;
	//	}
	//}
	//return str;
